home *** CD-ROM | disk | FTP | other *** search
/ Chip 2007 January, February, March & April / Chip-Cover-CD-2007-02.iso / Pakiet bezpieczenstwa / mini Pentoo LiveCD 2006.1 / mpentoo-2006.1.iso / livecd.squashfs / usr / include / bits / string.h < prev    next >
C/C++ Source or Header  |  2006-05-08  |  57KB  |  1,971 lines
  1. /* Optimized, inlined string functions.  i486 version.
  2.    Copyright (C) 1997,1998,1999,2000,2001,2002,2003,2004
  3.        Free Software Foundation, Inc.
  4.    This file is part of the GNU C Library.
  5.  
  6.    The GNU C Library is free software; you can redistribute it and/or
  7.    modify it under the terms of the GNU Lesser General Public
  8.    License as published by the Free Software Foundation; either
  9.    version 2.1 of the License, or (at your option) any later version.
  10.  
  11.    The GNU C Library is distributed in the hope that it will be useful,
  12.    but WITHOUT ANY WARRANTY; without even the implied warranty of
  13.    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14.    Lesser General Public License for more details.
  15.  
  16.    You should have received a copy of the GNU Lesser General Public
  17.    License along with the GNU C Library; if not, write to the Free
  18.    Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
  19.    02111-1307 USA.  */
  20.  
  21. #ifndef _STRING_H
  22. # error "Never use <bits/string.h> directly; include <string.h> instead."
  23. #endif
  24.  
  25. /* The ix86 processors can access unaligned multi-byte variables.  */
  26. #define _STRING_ARCH_unaligned    1
  27.  
  28.  
  29. /* We only provide optimizations if the user selects them and if
  30.    GNU CC is used.  */
  31. #if !defined __NO_STRING_INLINES && defined __USE_STRING_INLINES \
  32.     && defined __GNUC__ && __GNUC__ >= 2 && !__BOUNDED_POINTERS__
  33.  
  34. #ifndef __STRING_INLINE
  35. # ifdef __cplusplus
  36. #  define __STRING_INLINE inline
  37. # else
  38. #  define __STRING_INLINE extern __inline
  39. # endif
  40. #endif
  41.  
  42. /* The macros are used in some of the optimized implementations below.  */
  43. #define __STRING_SMALL_GET16(src, idx) \
  44.   ((((__const unsigned char *) (src))[idx + 1] << 8)                  \
  45.    | ((__const unsigned char *) (src))[idx])
  46. #define __STRING_SMALL_GET32(src, idx) \
  47.   (((((__const unsigned char *) (src))[idx + 3] << 8                  \
  48.      | ((__const unsigned char *) (src))[idx + 2]) << 8                  \
  49.     | ((__const unsigned char *) (src))[idx + 1]) << 8                  \
  50.    | ((__const unsigned char *) (src))[idx])
  51.  
  52.  
  53. /* Copy N bytes of SRC to DEST.  */
  54. #define _HAVE_STRING_ARCH_memcpy 1
  55. #define memcpy(dest, src, n) \
  56.   (__extension__ (__builtin_constant_p (n)                      \
  57.           ? __memcpy_c ((dest), (src), (n))                  \
  58.           : __memcpy_g ((dest), (src), (n))))
  59. #define __memcpy_c(dest, src, n) \
  60.   ((n) == 0                                      \
  61.    ? (dest)                                      \
  62.    : (((n) % 4 == 0)                                  \
  63.       ? __memcpy_by4 (dest, src, n)                          \
  64.       : (((n) % 2 == 0)                                  \
  65.      ? __memcpy_by2 (dest, src, n)                          \
  66.      : __memcpy_g (dest, src, n))))
  67.  
  68. __STRING_INLINE void *__memcpy_by4 (void *__dest, __const void *__src,
  69.                     size_t __n);
  70.  
  71. __STRING_INLINE void *
  72. __memcpy_by4 (void *__dest, __const void *__src, size_t __n)
  73. {
  74.   register unsigned long int __d0, __d1;
  75.   register void *__tmp = __dest;
  76.   __asm__ __volatile__
  77.     ("1:\n\t"
  78.      "movl    (%2),%0\n\t"
  79.      "leal    4(%2),%2\n\t"
  80.      "movl    %0,(%1)\n\t"
  81.      "leal    4(%1),%1\n\t"
  82.      "decl    %3\n\t"
  83.      "jnz    1b"
  84.      : "=&r" (__d0), "=&r" (__tmp), "=&r" (__src), "=&r" (__d1)
  85.      : "1" (__tmp), "2" (__src), "3" (__n / 4)
  86.      : "memory", "cc");
  87.   return __dest;
  88. }
  89.  
  90. __STRING_INLINE void *__memcpy_by2 (void *__dest, __const void *__src,
  91.                     size_t __n);
  92.  
  93. __STRING_INLINE void *
  94. __memcpy_by2 (void *__dest, __const void *__src, size_t __n)
  95. {
  96.   register unsigned long int __d0, __d1;
  97.   register void *__tmp = __dest;
  98.   __asm__ __volatile__
  99.     ("shrl    $1,%3\n\t"
  100.      "jz    2f\n"                 /* only a word */
  101.      "1:\n\t"
  102.      "movl    (%2),%0\n\t"
  103.      "leal    4(%2),%2\n\t"
  104.      "movl    %0,(%1)\n\t"
  105.      "leal    4(%1),%1\n\t"
  106.      "decl    %3\n\t"
  107.      "jnz    1b\n"
  108.      "2:\n\t"
  109.      "movw    (%2),%w0\n\t"
  110.      "movw    %w0,(%1)"
  111.      : "=&q" (__d0), "=&r" (__tmp), "=&r" (__src), "=&r" (__d1)
  112.      : "1" (__tmp), "2" (__src), "3" (__n / 2)
  113.      : "memory", "cc");
  114.   return __dest;
  115. }
  116.  
  117. __STRING_INLINE void *__memcpy_g (void *__dest, __const void *__src,
  118.                   size_t __n);
  119.  
  120. __STRING_INLINE void *
  121. __memcpy_g (void *__dest, __const void *__src, size_t __n)
  122. {
  123.   register unsigned long int __d0, __d1, __d2;
  124.   register void *__tmp = __dest;
  125.   __asm__ __volatile__
  126.     ("cld\n\t"
  127.      "shrl    $1,%%ecx\n\t"
  128.      "jnc    1f\n\t"
  129.      "movsb\n"
  130.      "1:\n\t"
  131.      "shrl    $1,%%ecx\n\t"
  132.      "jnc    2f\n\t"
  133.      "movsw\n"
  134.      "2:\n\t"
  135.      "rep; movsl"
  136.      : "=&c" (__d0), "=&D" (__d1), "=&S" (__d2),
  137.        "=m" ( *(struct { __extension__ char __x[__n]; } *)__dest)
  138.      : "0" (__n), "1" (__tmp), "2" (__src),
  139.        "m" ( *(struct { __extension__ char __x[__n]; } *)__src)
  140.      : "cc");
  141.   return __dest;
  142. }
  143.  
  144. #define _HAVE_STRING_ARCH_memmove 1
  145. #ifndef _FORCE_INLINES
  146. /* Copy N bytes of SRC to DEST, guaranteeing
  147.    correct behavior for overlapping strings.  */
  148. __STRING_INLINE void *
  149. memmove (void *__dest, __const void *__src, size_t __n)
  150. {
  151.   register unsigned long int __d0, __d1, __d2;
  152.   register void *__tmp = __dest;
  153.   if (__dest < __src)
  154.     __asm__ __volatile__
  155.       ("cld\n\t"
  156.        "rep; movsb"
  157.        : "=&c" (__d0), "=&S" (__d1), "=&D" (__d2),
  158.      "=m" ( *(struct { __extension__ char __x[__n]; } *)__dest)
  159.        : "0" (__n), "1" (__src), "2" (__tmp),
  160.      "m" ( *(struct { __extension__ char __x[__n]; } *)__src));
  161.   else
  162.     __asm__ __volatile__
  163.       ("std\n\t"
  164.        "rep; movsb\n\t"
  165.        "cld"
  166.        : "=&c" (__d0), "=&S" (__d1), "=&D" (__d2),
  167.      "=m" ( *(struct { __extension__ char __x[__n]; } *)__dest)
  168.        : "0" (__n), "1" (__n - 1 + (__const char *) __src),
  169.      "2" (__n - 1 + (char *) __tmp),
  170.      "m" ( *(struct { __extension__ char __x[__n]; } *)__src));
  171.   return __dest;
  172. }
  173. #endif
  174.  
  175. /* Compare N bytes of S1 and S2.  */
  176. #define _HAVE_STRING_ARCH_memcmp 1
  177. #ifndef _FORCE_INLINES
  178. # ifndef __PIC__
  179. /* gcc has problems to spill registers when using PIC.  */
  180. __STRING_INLINE int
  181. memcmp (__const void *__s1, __const void *__s2, size_t __n)
  182. {
  183.   register unsigned long int __d0, __d1, __d2;
  184.   register int __res;
  185.   __asm__ __volatile__
  186.     ("cld\n\t"
  187.      "testl %3,%3\n\t"
  188.      "repe; cmpsb\n\t"
  189.      "je    1f\n\t"
  190.      "sbbl    %0,%0\n\t"
  191.      "orl    $1,%0\n"
  192.      "1:"
  193.      : "=&a" (__res), "=&S" (__d0), "=&D" (__d1), "=&c" (__d2)
  194.      : "0" (0), "1" (__s1), "2" (__s2), "3" (__n),
  195.        "m" ( *(struct { __extension__ char __x[__n]; } *)__s1),
  196.        "m" ( *(struct { __extension__ char __x[__n]; } *)__s2)
  197.      : "cc");
  198.   return __res;
  199. }
  200. # endif
  201. #endif
  202.  
  203. /* Set N bytes of S to C.  */
  204. #define _HAVE_STRING_ARCH_memset 1
  205. #define _USE_STRING_ARCH_memset 1
  206. #define memset(s, c, n) \
  207.   (__extension__ (__builtin_constant_p (n) && (n) <= 16                  \
  208.           ? ((n) == 1                              \
  209.              ? __memset_c1 ((s), (c))                      \
  210.              : __memset_gc ((s), (c), (n)))                  \
  211.           : (__builtin_constant_p (c)                      \
  212.              ? (__builtin_constant_p (n)                  \
  213.             ? __memset_ccn ((s), (c), (n))                  \
  214.             : memset ((s), (c), (n)))                  \
  215.              : (__builtin_constant_p (n)                  \
  216.             ? __memset_gcn ((s), (c), (n))                  \
  217.             : memset ((s), (c), (n))))))
  218.  
  219. #define __memset_c1(s, c) ({ void *__s = (s);                      \
  220.                  *((unsigned char *) __s) = (unsigned char) (c);  \
  221.                  __s; })
  222.  
  223. #define __memset_gc(s, c, n) \
  224.   ({ void *__s = (s);                                  \
  225.      union {                                      \
  226.        unsigned int __ui;                              \
  227.        unsigned short int __usi;                          \
  228.        unsigned char __uc;                              \
  229.      } *__u = __s;                                  \
  230.      unsigned int __c = ((unsigned int) ((unsigned char) (c))) * 0x01010101;  \
  231.                                           \
  232.      /* We apply a trick here.  `gcc' would implement the following          \
  233.     assignments using immediate operands.  But this uses to much          \
  234.     memory (7, instead of 4 bytes).  So we force the value in a          \
  235.     registers.  */                                  \
  236.      if ((n) == 3 || (n) >= 5)                              \
  237.        __asm__ __volatile__ ("" : "=r" (__c) : "0" (__c));              \
  238.                                           \
  239.      /* This `switch' statement will be removed at compile-time.  */          \
  240.      switch (n)                                      \
  241.        {                                      \
  242.        case 15:                                      \
  243.      __u->__ui = __c;                              \
  244.      __u = __extension__ ((void *) __u + 4);                  \
  245.        case 11:                                      \
  246.      __u->__ui = __c;                              \
  247.      __u = __extension__ ((void *) __u + 4);                  \
  248.        case 7:                                      \
  249.      __u->__ui = __c;                              \
  250.      __u = __extension__ ((void *) __u + 4);                  \
  251.        case 3:                                      \
  252.      __u->__usi = (unsigned short int) __c;                      \
  253.      __u = __extension__ ((void *) __u + 2);                  \
  254.      __u->__uc = (unsigned char) __c;                      \
  255.      break;                                      \
  256.                                           \
  257.        case 14:                                      \
  258.      __u->__ui = __c;                              \
  259.      __u = __extension__ ((void *) __u + 4);                  \
  260.        case 10:                                      \
  261.      __u->__ui = __c;                              \
  262.      __u = __extension__ ((void *) __u + 4);                  \
  263.        case 6:                                      \
  264.      __u->__ui = __c;                              \
  265.      __u = __extension__ ((void *) __u + 4);                  \
  266.        case 2:                                      \
  267.      __u->__usi = (unsigned short int) __c;                      \
  268.      break;                                      \
  269.                                           \
  270.        case 13:                                      \
  271.      __u->__ui = __c;                              \
  272.      __u = __extension__ ((void *) __u + 4);                  \
  273.        case 9:                                      \
  274.      __u->__ui = __c;                              \
  275.      __u = __extension__ ((void *) __u + 4);                  \
  276.        case 5:                                      \
  277.      __u->__ui = __c;                              \
  278.      __u = __extension__ ((void *) __u + 4);                  \
  279.        case 1:                                      \
  280.      __u->__uc = (unsigned char) __c;                      \
  281.      break;                                      \
  282.                                           \
  283.        case 16:                                      \
  284.      __u->__ui = __c;                              \
  285.      __u = __extension__ ((void *) __u + 4);                  \
  286.        case 12:                                      \
  287.      __u->__ui = __c;                              \
  288.      __u = __extension__ ((void *) __u + 4);                  \
  289.        case 8:                                      \
  290.      __u->__ui = __c;                              \
  291.      __u = __extension__ ((void *) __u + 4);                  \
  292.        case 4:                                      \
  293.      __u->__ui = __c;                              \
  294.        case 0:                                      \
  295.      break;                                      \
  296.        }                                      \
  297.                                           \
  298.      __s; })
  299.  
  300. #define __memset_ccn(s, c, n) \
  301.   (((n) % 4 == 0)                                  \
  302.    ? __memset_ccn_by4 (s, ((unsigned int) ((unsigned char) (c))) * 0x01010101,\
  303.                n)                              \
  304.    : (((n) % 2 == 0)                                  \
  305.       ? __memset_ccn_by2 (s,                              \
  306.               ((unsigned int) ((unsigned char) (c))) * 0x01010101,\
  307.                n)                              \
  308.       : memset (s, c, n)))
  309.  
  310. __STRING_INLINE void *__memset_ccn_by4 (void *__s, unsigned int __c,
  311.                     size_t __n);
  312.  
  313. __STRING_INLINE void *
  314. __memset_ccn_by4 (void *__s, unsigned int __c, size_t __n)
  315. {
  316.   register void *__tmp = __s;
  317.   register unsigned long int __d0;
  318. #ifdef __i686__
  319.   __asm__ __volatile__
  320.     ("cld\n\t"
  321.      "rep; stosl"
  322.      : "=&a" (__c), "=&D" (__tmp), "=&c" (__d0),
  323.        "=m" ( *(struct { __extension__ char __x[__n]; } *)__s)
  324.      : "0" ((unsigned int) __c), "1" (__tmp), "2" (__n / 4)
  325.      : "cc");
  326. #else
  327.   __asm__ __volatile__
  328.     ("1:\n\t"
  329.      "movl    %0,(%1)\n\t"
  330.      "addl    $4,%1\n\t"
  331.      "decl    %2\n\t"
  332.      "jnz    1b\n"
  333.      : "=&r" (__c), "=&r" (__tmp), "=&r" (__d0),
  334.        "=m" ( *(struct { __extension__ char __x[__n]; } *)__s)
  335.      : "0" ((unsigned int) __c), "1" (__tmp), "2" (__n / 4)
  336.      : "cc");
  337. #endif
  338.   return __s;
  339. }
  340.  
  341. __STRING_INLINE void *__memset_ccn_by2 (void *__s, unsigned int __c,
  342.                     size_t __n);
  343.  
  344. __STRING_INLINE void *
  345. __memset_ccn_by2 (void *__s, unsigned int __c, size_t __n)
  346. {
  347.   register unsigned long int __d0, __d1;
  348.   register void *__tmp = __s;
  349. #ifdef __i686__
  350.   __asm__ __volatile__
  351.     ("cld\n\t"
  352.      "rep; stosl\n"
  353.      "stosw"
  354.      : "=&a" (__d0), "=&D" (__tmp), "=&c" (__d1),
  355.        "=m" ( *(struct { __extension__ char __x[__n]; } *)__s)
  356.      : "0" ((unsigned int) __c), "1" (__tmp), "2" (__n / 4)
  357.      : "cc");
  358. #else
  359.   __asm__ __volatile__
  360.     ("1:\tmovl    %0,(%1)\n\t"
  361.      "leal    4(%1),%1\n\t"
  362.      "decl    %2\n\t"
  363.      "jnz    1b\n"
  364.      "movw    %w0,(%1)"
  365.      : "=&q" (__d0), "=&r" (__tmp), "=&r" (__d1),
  366.        "=m" ( *(struct { __extension__ char __x[__n]; } *)__s)
  367.      : "0" ((unsigned int) __c), "1" (__tmp), "2" (__n / 4)
  368.      : "cc");
  369. #endif
  370.   return __s;
  371. }
  372.  
  373. #define __memset_gcn(s, c, n) \
  374.   (((n) % 4 == 0)                                  \
  375.    ? __memset_gcn_by4 (s, c, n)                              \
  376.    : (((n) % 2 == 0)                                  \
  377.       ? __memset_gcn_by2 (s, c, n)                          \
  378.       : memset (s, c, n)))
  379.  
  380. __STRING_INLINE void *__memset_gcn_by4 (void *__s, int __c, size_t __n);
  381.  
  382. __STRING_INLINE void *
  383. __memset_gcn_by4 (void *__s, int __c, size_t __n)
  384. {
  385.   register void *__tmp = __s;
  386.   register unsigned long int __d0;
  387.   __asm__ __volatile__
  388.     ("movb    %b0,%h0\n"
  389.      "pushw    %w0\n\t"
  390.      "shll    $16,%0\n\t"
  391.      "popw    %w0\n"
  392.      "1:\n\t"
  393.      "movl    %0,(%1)\n\t"
  394.      "addl    $4,%1\n\t"
  395.      "decl    %2\n\t"
  396.      "jnz    1b\n"
  397.      : "=&q" (__c), "=&r" (__tmp), "=&r" (__d0),
  398.        "=m" ( *(struct { __extension__ char __x[__n]; } *)__s)
  399.      : "0" ((unsigned int) __c), "1" (__tmp), "2" (__n / 4)
  400.      : "cc");
  401.   return __s;
  402. }
  403.  
  404. __STRING_INLINE void *__memset_gcn_by2 (void *__s, int __c, size_t __n);
  405.  
  406. __STRING_INLINE void *
  407. __memset_gcn_by2 (void *__s, int __c, size_t __n)
  408. {
  409.   register unsigned long int __d0, __d1;
  410.   register void *__tmp = __s;
  411.   __asm__ __volatile__
  412.     ("movb    %b0,%h0\n\t"
  413.      "pushw    %w0\n\t"
  414.      "shll    $16,%0\n\t"
  415.      "popw    %w0\n"
  416.      "1:\n\t"
  417.      "movl    %0,(%1)\n\t"
  418.      "leal    4(%1),%1\n\t"
  419.      "decl    %2\n\t"
  420.      "jnz    1b\n"
  421.      "movw    %w0,(%1)"
  422.      : "=&q" (__d0), "=&r" (__tmp), "=&r" (__d1),
  423.        "=m" ( *(struct { __extension__ char __x[__n]; } *)__s)
  424.      : "0" ((unsigned int) __c), "1" (__tmp), "2" (__n / 4)
  425.      : "cc");
  426.   return __s;
  427. }
  428.  
  429.  
  430. /* Search N bytes of S for C.  */
  431. #define _HAVE_STRING_ARCH_memchr 1
  432. #ifndef _FORCE_INLINES
  433. __STRING_INLINE void *
  434. memchr (__const void *__s, int __c, size_t __n)
  435. {
  436.   register unsigned long int __d0;
  437. #ifdef __i686__
  438.   register unsigned long int __d1;
  439. #endif
  440.   register unsigned char *__res;
  441.   if (__n == 0)
  442.     return NULL;
  443. #ifdef __i686__
  444.   __asm__ __volatile__
  445.     ("cld\n\t"
  446.      "repne; scasb\n\t"
  447.      "cmovne %2,%0"
  448.      : "=D" (__res), "=&c" (__d0), "=&r" (__d1)
  449.      : "a" (__c), "0" (__s), "1" (__n), "2" (1),
  450.        "m" ( *(struct { __extension__ char __x[__n]; } *)__s)
  451.      : "cc");
  452. #else
  453.   __asm__ __volatile__
  454.     ("cld\n\t"
  455.      "repne; scasb\n\t"
  456.      "je    1f\n\t"
  457.      "movl    $1,%0\n"
  458.      "1:"
  459.      : "=D" (__res), "=&c" (__d0)
  460.      : "a" (__c), "0" (__s), "1" (__n),
  461.        "m" ( *(struct { __extension__ char __x[__n]; } *)__s)
  462.      : "cc");
  463. #endif
  464.   return __res - 1;
  465. }
  466. #endif
  467.  
  468. #define _HAVE_STRING_ARCH_memrchr 1
  469. #ifndef _FORCE_INLINES
  470. __STRING_INLINE void *__memrchr (__const void *__s, int __c, size_t __n);
  471.  
  472. __STRING_INLINE void *
  473. __memrchr (__const void *__s, int __c, size_t __n)
  474. {
  475.   register unsigned long int __d0;
  476. # ifdef __i686__
  477.   register unsigned long int __d1;
  478. # endif
  479.   register void *__res;
  480.   if (__n == 0)
  481.     return NULL;
  482. # ifdef __i686__
  483.   __asm__ __volatile__
  484.     ("std\n\t"
  485.      "repne; scasb\n\t"
  486.      "cmovne %2,%0\n\t"
  487.      "cld\n\t"
  488.      "incl %0"
  489.      : "=D" (__res), "=&c" (__d0), "=&r" (__d1)
  490.      : "a" (__c), "0" (__s + __n - 1), "1" (__n), "2" (-1),
  491.        "m" ( *(struct { __extension__ char __x[__n]; } *)__s)
  492.      : "cc");
  493. # else
  494.   __asm__ __volatile__
  495.     ("std\n\t"
  496.      "repne; scasb\n\t"
  497.      "je 1f\n\t"
  498.      "orl $-1,%0\n"
  499.      "1:\tcld\n\t"
  500.      "incl %0"
  501.      : "=D" (__res), "=&c" (__d0)
  502.      : "a" (__c), "0" (__s + __n - 1), "1" (__n),
  503.        "m" ( *(struct { __extension__ char __x[__n]; } *)__s)
  504.      : "cc");
  505. # endif
  506.   return __res;
  507. }
  508. # ifdef __USE_GNU
  509. #  define memrchr(s, c, n) __memrchr ((s), (c), (n))
  510. # endif
  511. #endif
  512.  
  513. /* Return pointer to C in S.  */
  514. #define _HAVE_STRING_ARCH_rawmemchr 1
  515. __STRING_INLINE void *__rawmemchr (const void *__s, int __c);
  516.  
  517. #ifndef _FORCE_INLINES
  518. __STRING_INLINE void *
  519. __rawmemchr (const void *__s, int __c)
  520. {
  521.   register unsigned long int __d0;
  522.   register unsigned char *__res;
  523.   __asm__ __volatile__
  524.     ("cld\n\t"
  525.      "repne; scasb\n\t"
  526.      : "=D" (__res), "=&c" (__d0)
  527.      : "a" (__c), "0" (__s), "1" (0xffffffff),
  528.        "m" ( *(struct { char __x[0xfffffff]; } *)__s)
  529.      : "cc");
  530.   return __res - 1;
  531. }
  532. # ifdef __USE_GNU
  533. __STRING_INLINE void *
  534. rawmemchr (const void *__s, int __c)
  535. {
  536.   return __rawmemchr (__s, __c);
  537. }
  538. # endif    /* use GNU */
  539. #endif
  540.  
  541.  
  542. /* Return the length of S.  */
  543. #define _HAVE_STRING_ARCH_strlen 1
  544. #define strlen(str) \
  545.   (__extension__ (__builtin_constant_p (str)                      \
  546.           ? __builtin_strlen (str)                      \
  547.           : __strlen_g (str)))
  548. __STRING_INLINE size_t __strlen_g (__const char *__str);
  549.  
  550. __STRING_INLINE size_t
  551. __strlen_g (__const char *__str)
  552. {
  553.   register char __dummy;
  554.   register __const char *__tmp = __str;
  555.   __asm__ __volatile__
  556.     ("1:\n\t"
  557.      "movb    (%0),%b1\n\t"
  558.      "leal    1(%0),%0\n\t"
  559.      "testb    %b1,%b1\n\t"
  560.      "jne    1b"
  561.      : "=r" (__tmp), "=&q" (__dummy)
  562.      : "0" (__str),
  563.        "m" ( *(struct { char __x[0xfffffff]; } *)__str)
  564.      : "cc" );
  565.   return __tmp - __str - 1;
  566. }
  567.  
  568.  
  569. /* Copy SRC to DEST.  */
  570. #define _HAVE_STRING_ARCH_strcpy 1
  571. #define strcpy(dest, src) \
  572.   (__extension__ (__builtin_constant_p (src)                      \
  573.           ? (sizeof ((src)[0]) == 1 && strlen (src) + 1 <= 8          \
  574.              ? __strcpy_a_small ((dest), (src), strlen (src) + 1)     \
  575.              : (char *) memcpy ((char *) (dest),              \
  576.                     (__const char *) (src),              \
  577.                     strlen (src) + 1))              \
  578.           : __strcpy_g ((dest), (src))))
  579.  
  580. #define __strcpy_a_small(dest, src, srclen) \
  581.   (__extension__ ({ char *__dest = (dest);                      \
  582.             union {                              \
  583.               unsigned int __ui;                      \
  584.               unsigned short int __usi;                      \
  585.               unsigned char __uc;                      \
  586.               char __c;                              \
  587.             } *__u = (void *) __dest;                      \
  588.             switch (srclen)                          \
  589.               {                                  \
  590.               case 1:                              \
  591.             __u->__uc = '\0';                      \
  592.             break;                              \
  593.               case 2:                              \
  594.             __u->__usi = __STRING_SMALL_GET16 (src, 0);          \
  595.             break;                              \
  596.               case 3:                              \
  597.             __u->__usi = __STRING_SMALL_GET16 (src, 0);          \
  598.             __u = __extension__ ((void *) __u + 2);              \
  599.             __u->__uc = '\0';                      \
  600.             break;                              \
  601.               case 4:                              \
  602.             __u->__ui = __STRING_SMALL_GET32 (src, 0);          \
  603.             break;                              \
  604.               case 5:                              \
  605.             __u->__ui = __STRING_SMALL_GET32 (src, 0);          \
  606.             __u = __extension__ ((void *) __u + 4);              \
  607.             __u->__uc = '\0';                      \
  608.             break;                              \
  609.               case 6:                              \
  610.             __u->__ui = __STRING_SMALL_GET32 (src, 0);          \
  611.             __u = __extension__ ((void *) __u + 4);              \
  612.             __u->__usi = __STRING_SMALL_GET16 (src, 4);          \
  613.             break;                              \
  614.               case 7:                              \
  615.             __u->__ui = __STRING_SMALL_GET32 (src, 0);          \
  616.             __u = __extension__ ((void *) __u + 4);              \
  617.             __u->__usi = __STRING_SMALL_GET16 (src, 4);          \
  618.             __u = __extension__ ((void *) __u + 2);              \
  619.             __u->__uc = '\0';                      \
  620.             break;                              \
  621.               case 8:                              \
  622.             __u->__ui = __STRING_SMALL_GET32 (src, 0);          \
  623.             __u = __extension__ ((void *) __u + 4);              \
  624.             __u->__ui = __STRING_SMALL_GET32 (src, 4);          \
  625.             break;                              \
  626.               }                                  \
  627.             (char *) __dest; }))
  628.  
  629. __STRING_INLINE char *__strcpy_g (char *__dest, __const char *__src);
  630.  
  631. __STRING_INLINE char *
  632. __strcpy_g (char *__dest, __const char *__src)
  633. {
  634.   register char *__tmp = __dest;
  635.   register char __dummy;
  636.   __asm__ __volatile__
  637.     (
  638.      "1:\n\t"
  639.      "movb    (%0),%b2\n\t"
  640.      "leal    1(%0),%0\n\t"
  641.      "movb    %b2,(%1)\n\t"
  642.      "leal    1(%1),%1\n\t"
  643.      "testb    %b2,%b2\n\t"
  644.      "jne    1b"
  645.      : "=&r" (__src), "=&r" (__tmp), "=&q" (__dummy),
  646.        "=m" ( *(struct { char __x[0xfffffff]; } *)__dest)
  647.      : "0" (__src), "1" (__tmp),
  648.        "m" ( *(struct { char __x[0xfffffff]; } *)__src)
  649.      : "cc");
  650.   return __dest;
  651. }
  652.  
  653.  
  654. #ifdef __USE_GNU
  655. # define _HAVE_STRING_ARCH_stpcpy 1
  656. /* Copy SRC to DEST.  */
  657. # define __stpcpy(dest, src) \
  658.   (__extension__ (__builtin_constant_p (src)                      \
  659.           ? (strlen (src) + 1 <= 8                      \
  660.              ? __stpcpy_a_small ((dest), (src), strlen (src) + 1)     \
  661.              : __stpcpy_c ((dest), (src), strlen (src) + 1))          \
  662.           : __stpcpy_g ((dest), (src))))
  663. # define __stpcpy_c(dest, src, srclen) \
  664.   ((srclen) % 4 == 0                                  \
  665.    ? __mempcpy_by4 (dest, src, srclen) - 1                      \
  666.    : ((srclen) % 2 == 0                                  \
  667.       ? __mempcpy_by2 (dest, src, srclen) - 1                      \
  668.       : __mempcpy_byn (dest, src, srclen) - 1))
  669.  
  670. /* In glibc itself we use this symbol for namespace reasons.  */
  671. # define stpcpy(dest, src) __stpcpy ((dest), (src))
  672.  
  673. # define __stpcpy_a_small(dest, src, srclen) \
  674.   (__extension__ ({ union {                              \
  675.               unsigned int __ui;                      \
  676.               unsigned short int __usi;                      \
  677.               unsigned char __uc;                      \
  678.               char __c;                              \
  679.             } *__u = (void *) (dest);                      \
  680.             switch (srclen)                          \
  681.               {                                  \
  682.               case 1:                              \
  683.             __u->__uc = '\0';                      \
  684.             break;                              \
  685.               case 2:                              \
  686.             __u->__usi = __STRING_SMALL_GET16 (src, 0);          \
  687.             __u = __extension__ ((void *) __u + 1);              \
  688.             break;                              \
  689.               case 3:                              \
  690.             __u->__usi = __STRING_SMALL_GET16 (src, 0);          \
  691.             __u = __extension__ ((void *) __u + 2);              \
  692.             __u->__uc = '\0';                      \
  693.             break;                              \
  694.               case 4:                              \
  695.             __u->__ui = __STRING_SMALL_GET32 (src, 0);          \
  696.             __u = __extension__ ((void *) __u + 3);              \
  697.             break;                              \
  698.               case 5:                              \
  699.             __u->__ui = __STRING_SMALL_GET32 (src, 0);          \
  700.             __u = __extension__ ((void *) __u + 4);              \
  701.             __u->__uc = '\0';                      \
  702.             break;                              \
  703.               case 6:                              \
  704.             __u->__ui = __STRING_SMALL_GET32 (src, 0);          \
  705.             __u = __extension__ ((void *) __u + 4);              \
  706.             __u->__usi = __STRING_SMALL_GET16 (src, 4);          \
  707.             __u = __extension__ ((void *) __u + 1);              \
  708.             break;                              \
  709.               case 7:                              \
  710.             __u->__ui = __STRING_SMALL_GET32 (src, 0);          \
  711.             __u = __extension__ ((void *) __u + 4);              \
  712.             __u->__usi = __STRING_SMALL_GET16 (src, 4);          \
  713.             __u = __extension__ ((void *) __u + 2);              \
  714.             __u->__uc = '\0';                      \
  715.             break;                              \
  716.               case 8:                              \
  717.             __u->__ui = __STRING_SMALL_GET32 (src, 0);          \
  718.             __u = __extension__ ((void *) __u + 4);              \
  719.             __u->__ui = __STRING_SMALL_GET32 (src, 4);          \
  720.             __u = __extension__ ((void *) __u + 3);              \
  721.             break;                              \
  722.               }                                  \
  723.             (char *) __u; }))
  724.  
  725. __STRING_INLINE char *__mempcpy_by4 (char *__dest, __const char *__src,
  726.                      size_t __srclen);
  727.  
  728. __STRING_INLINE char *
  729. __mempcpy_by4 (char *__dest, __const char *__src, size_t __srclen)
  730. {
  731.   register char *__tmp = __dest;
  732.   register unsigned long int __d0, __d1;
  733.   __asm__ __volatile__
  734.     ("1:\n\t"
  735.      "movl    (%2),%0\n\t"
  736.      "leal    4(%2),%2\n\t"
  737.      "movl    %0,(%1)\n\t"
  738.      "leal    4(%1),%1\n\t"
  739.      "decl    %3\n\t"
  740.      "jnz    1b"
  741.      : "=&r" (__d0), "=r" (__tmp), "=&r" (__src), "=&r" (__d1)
  742.      : "1" (__tmp), "2" (__src), "3" (__srclen / 4)
  743.      : "memory", "cc");
  744.   return __tmp;
  745. }
  746.  
  747. __STRING_INLINE char *__mempcpy_by2 (char *__dest, __const char *__src,
  748.                      size_t __srclen);
  749.  
  750. __STRING_INLINE char *
  751. __mempcpy_by2 (char *__dest, __const char *__src, size_t __srclen)
  752. {
  753.   register char *__tmp = __dest;
  754.   register unsigned long int __d0, __d1;
  755.   __asm__ __volatile__
  756.     ("shrl    $1,%3\n\t"
  757.      "jz    2f\n"                 /* only a word */
  758.      "1:\n\t"
  759.      "movl    (%2),%0\n\t"
  760.      "leal    4(%2),%2\n\t"
  761.      "movl    %0,(%1)\n\t"
  762.      "leal    4(%1),%1\n\t"
  763.      "decl    %3\n\t"
  764.      "jnz    1b\n"
  765.      "2:\n\t"
  766.      "movw    (%2),%w0\n\t"
  767.      "movw    %w0,(%1)"
  768.      : "=&q" (__d0), "=r" (__tmp), "=&r" (__src), "=&r" (__d1),
  769.        "=m" ( *(struct { __extension__ char __x[__srclen]; } *)__dest)
  770.      : "1" (__tmp), "2" (__src), "3" (__srclen / 2),
  771.        "m" ( *(struct { __extension__ char __x[__srclen]; } *)__src)
  772.      : "cc");
  773.   return __tmp + 2;
  774. }
  775.  
  776. __STRING_INLINE char *__mempcpy_byn (char *__dest, __const char *__src,
  777.                      size_t __srclen);
  778.  
  779. __STRING_INLINE char *
  780. __mempcpy_byn (char *__dest, __const char *__src, size_t __srclen)
  781. {
  782.   register unsigned long __d0, __d1;
  783.   register char *__tmp = __dest;
  784.   __asm__ __volatile__
  785.     ("cld\n\t"
  786.      "shrl    $1,%%ecx\n\t"
  787.      "jnc    1f\n\t"
  788.      "movsb\n"
  789.      "1:\n\t"
  790.      "shrl    $1,%%ecx\n\t"
  791.      "jnc    2f\n\t"
  792.      "movsw\n"
  793.      "2:\n\t"
  794.      "rep; movsl"
  795.      : "=D" (__tmp), "=&c" (__d0), "=&S" (__d1),
  796.        "=m" ( *(struct { __extension__ char __x[__srclen]; } *)__dest)
  797.      : "0" (__tmp), "1" (__srclen), "2" (__src),
  798.        "m" ( *(struct { __extension__ char __x[__srclen]; } *)__src)
  799.      : "cc");
  800.   return __tmp;
  801. }
  802.  
  803. __STRING_INLINE char *__stpcpy_g (char *__dest, __const char *__src);
  804.  
  805. __STRING_INLINE char *
  806. __stpcpy_g (char *__dest, __const char *__src)
  807. {
  808.   register char *__tmp = __dest;
  809.   register char __dummy;
  810.   __asm__ __volatile__
  811.     (
  812.      "1:\n\t"
  813.      "movb    (%0),%b2\n\t"
  814.      "leal    1(%0),%0\n\t"
  815.      "movb    %b2,(%1)\n\t"
  816.      "leal    1(%1),%1\n\t"
  817.      "testb    %b2,%b2\n\t"
  818.      "jne    1b"
  819.      : "=&r" (__src), "=r" (__tmp), "=&q" (__dummy),
  820.        "=m" ( *(struct { char __x[0xfffffff]; } *)__dest)
  821.      : "0" (__src), "1" (__tmp),
  822.        "m" ( *(struct { char __x[0xfffffff]; } *)__src)
  823.      : "cc");
  824.   return __tmp - 1;
  825. }
  826. #endif
  827.  
  828.  
  829. /* Copy no more than N characters of SRC to DEST.  */
  830. #define _HAVE_STRING_ARCH_strncpy 1
  831. #define strncpy(dest, src, n) \
  832.   (__extension__ (__builtin_constant_p (src)                      \
  833.           ? ((strlen (src) + 1 >= ((size_t) (n))              \
  834.               ? (char *) memcpy ((char *) (dest),              \
  835.                      (__const char *) (src), n)          \
  836.               : __strncpy_cg ((dest), (src), strlen (src) + 1, n)))   \
  837.           : __strncpy_gg ((dest), (src), n)))
  838. #define __strncpy_cg(dest, src, srclen, n) \
  839.   (((srclen) % 4 == 0)                                  \
  840.    ? __strncpy_by4 (dest, src, srclen, n)                      \
  841.    : (((srclen) % 2 == 0)                              \
  842.       ? __strncpy_by2 (dest, src, srclen, n)                      \
  843.       : __strncpy_byn (dest, src, srclen, n)))
  844.  
  845. __STRING_INLINE char *__strncpy_by4 (char *__dest, __const char __src[],
  846.                      size_t __srclen, size_t __n);
  847.  
  848. __STRING_INLINE char *
  849. __strncpy_by4 (char *__dest, __const char __src[], size_t __srclen, size_t __n)
  850. {
  851.   register char *__tmp = __dest;
  852.   register int __dummy1, __dummy2;
  853.   __asm__ __volatile__
  854.     ("1:\n\t"
  855.      "movl    (%2),%0\n\t"
  856.      "leal    4(%2),%2\n\t"
  857.      "movl    %0,(%1)\n\t"
  858.      "leal    4(%1),%1\n\t"
  859.      "decl    %3\n\t"
  860.      "jnz    1b"
  861.      : "=&r" (__dummy1), "=r" (__tmp), "=&r" (__src), "=&r" (__dummy2),
  862.        "=m" ( *(struct { __extension__ char __x[__srclen]; } *)__dest)
  863.      : "1" (__tmp), "2" (__src), "3" (__srclen / 4),
  864.        "m" ( *(struct { __extension__ char __x[__srclen]; } *)__src)
  865.      : "cc");
  866.   (void) memset (__tmp, '\0', __n - __srclen);
  867.   return __dest;
  868. }
  869.  
  870. __STRING_INLINE char *__strncpy_by2 (char *__dest, __const char __src[],
  871.                      size_t __srclen, size_t __n);
  872.  
  873. __STRING_INLINE char *
  874. __strncpy_by2 (char *__dest, __const char __src[], size_t __srclen, size_t __n)
  875. {
  876.   register char *__tmp = __dest;
  877.   register int __dummy1, __dummy2;
  878.   __asm__ __volatile__
  879.     ("shrl    $1,%3\n\t"
  880.      "jz    2f\n"                 /* only a word */
  881.      "1:\n\t"
  882.      "movl    (%2),%0\n\t"
  883.      "leal    4(%2),%2\n\t"
  884.      "movl    %0,(%1)\n\t"
  885.      "leal    4(%1),%1\n\t"
  886.      "decl    %3\n\t"
  887.      "jnz    1b\n"
  888.      "2:\n\t"
  889.      "movw    (%2),%w0\n\t"
  890.      "movw    %w0,(%1)\n\t"
  891.      : "=&q" (__dummy1), "=r" (__tmp), "=&r" (__src), "=&r" (__dummy2),
  892.        "=m" ( *(struct { __extension__ char __x[__srclen]; } *)__dest)
  893.      : "1" (__tmp), "2" (__src), "3" (__srclen / 2),
  894.        "m" ( *(struct { __extension__ char __x[__srclen]; } *)__src)
  895.      : "cc");
  896.   (void) memset (__tmp + 2, '\0', __n - __srclen);
  897.   return __dest;
  898. }
  899.  
  900. __STRING_INLINE char *__strncpy_byn (char *__dest, __const char __src[],
  901.                      size_t __srclen, size_t __n);
  902.  
  903. __STRING_INLINE char *
  904. __strncpy_byn (char *__dest, __const char __src[], size_t __srclen, size_t __n)
  905. {
  906.   register unsigned long int __d0, __d1;
  907.   register char *__tmp = __dest;
  908.   __asm__ __volatile__
  909.     ("cld\n\t"
  910.      "shrl    $1,%1\n\t"
  911.      "jnc    1f\n\t"
  912.      "movsb\n"
  913.      "1:\n\t"
  914.      "shrl    $1,%1\n\t"
  915.      "jnc    2f\n\t"
  916.      "movsw\n"
  917.      "2:\n\t"
  918.      "rep; movsl"
  919.      : "=D" (__tmp), "=&c" (__d0), "=&S" (__d1),
  920.        "=m" ( *(struct { __extension__ char __x[__srclen]; } *)__dest)
  921.      : "1" (__srclen), "0" (__tmp),"2" (__src),
  922.        "m" ( *(struct { __extension__ char __x[__srclen]; } *)__src)
  923.      : "cc");
  924.   (void) memset (__tmp, '\0', __n - __srclen);
  925.   return __dest;
  926. }
  927.  
  928. __STRING_INLINE char *__strncpy_gg (char *__dest, __const char *__src,
  929.                     size_t __n);
  930.  
  931. __STRING_INLINE char *
  932. __strncpy_gg (char *__dest, __const char *__src, size_t __n)
  933. {
  934.   register char *__tmp = __dest;
  935.   register char __dummy;
  936.   if (__n > 0)
  937.     __asm__ __volatile__
  938.       ("1:\n\t"
  939.        "movb    (%0),%2\n\t"
  940.        "incl    %0\n\t"
  941.        "movb    %2,(%1)\n\t"
  942.        "incl    %1\n\t"
  943.        "decl    %3\n\t"
  944.        "je    3f\n\t"
  945.        "testb    %2,%2\n\t"
  946.        "jne    1b\n\t"
  947.        "2:\n\t"
  948.        "movb    %2,(%1)\n\t"
  949.        "incl    %1\n\t"
  950.        "decl    %3\n\t"
  951.        "jne    2b\n\t"
  952.        "3:"
  953.        : "=&r" (__src), "=&r" (__tmp), "=&q" (__dummy), "=&r" (__n)
  954.        : "0" (__src), "1" (__tmp), "3" (__n)
  955.        : "memory", "cc");
  956.  
  957.   return __dest;
  958. }
  959.  
  960.  
  961. /* Append SRC onto DEST.  */
  962. #define _HAVE_STRING_ARCH_strcat 1
  963. #define strcat(dest, src) \
  964.   (__extension__ (__builtin_constant_p (src)                      \
  965.           ? __strcat_c ((dest), (src), strlen (src) + 1)          \
  966.           : __strcat_g ((dest), (src))))
  967.  
  968. __STRING_INLINE char *__strcat_c (char *__dest, __const char __src[],
  969.                   size_t __srclen);
  970.  
  971. __STRING_INLINE char *
  972. __strcat_c (char *__dest, __const char __src[], size_t __srclen)
  973. {
  974. #ifdef __i686__
  975.   register unsigned long int __d0;
  976.   register char *__tmp;
  977.   __asm__ __volatile__
  978.     ("repne; scasb"
  979.      : "=D" (__tmp), "=&c" (__d0),
  980.        "=m" ( *(struct { char __x[0xfffffff]; } *)__dest)
  981.      : "0" (__dest), "1" (0xffffffff), "a" (0),
  982.        "m" ( *(struct { __extension__ char __x[__srclen]; } *)__src)
  983.      : "cc");
  984.   --__tmp;
  985. #else
  986.   register char *__tmp = __dest - 1;
  987.   __asm__ __volatile__
  988.     ("1:\n\t"
  989.      "incl    %0\n\t"
  990.      "cmpb    $0,(%0)\n\t"
  991.      "jne    1b\n"
  992.      : "=r" (__tmp),
  993.        "=m" ( *(struct { char __x[0xfffffff]; } *)__dest)
  994.      : "0" (__tmp),
  995.        "m" ( *(struct { __extension__ char __x[__srclen]; } *)__src)
  996.      : "cc");
  997. #endif
  998.   (void) memcpy (__tmp, __src, __srclen);
  999.   return __dest;
  1000. }
  1001.  
  1002. __STRING_INLINE char *__strcat_g (char *__dest, __const char *__src);
  1003.  
  1004. __STRING_INLINE char *
  1005. __strcat_g (char *__dest, __const char *__src)
  1006. {
  1007.   register char *__tmp = __dest - 1;
  1008.   register char __dummy;
  1009.   __asm__ __volatile__
  1010.     ("1:\n\t"
  1011.      "incl    %1\n\t"
  1012.      "cmpb    $0,(%1)\n\t"
  1013.      "jne    1b\n"
  1014.      "2:\n\t"
  1015.      "movb    (%2),%b0\n\t"
  1016.      "incl    %2\n\t"
  1017.      "movb    %b0,(%1)\n\t"
  1018.      "incl    %1\n\t"
  1019.      "testb    %b0,%b0\n\t"
  1020.      "jne    2b\n"
  1021.      : "=&q" (__dummy), "=&r" (__tmp), "=&r" (__src),
  1022.        "=m" ( *(struct { char __x[0xfffffff]; } *)__dest)
  1023.      : "1"  (__tmp), "2"  (__src),
  1024.        "m" ( *(struct { char __x[0xfffffff]; } *)__src)
  1025.      : "memory", "cc");
  1026.   return __dest;
  1027. }
  1028.  
  1029.  
  1030. /* Append no more than N characters from SRC onto DEST.  */
  1031. #define _HAVE_STRING_ARCH_strncat 1
  1032. #define strncat(dest, src, n) \
  1033.   (__extension__ ({ char *__dest = (dest);                      \
  1034.             __builtin_constant_p (src) && __builtin_constant_p (n)    \
  1035.             ? (strlen (src) < ((size_t) (n))                  \
  1036.                ? strcat (__dest, (src))                      \
  1037.                : (*(char *)__mempcpy (strchr (__dest, '\0'),          \
  1038.                            (__const char *) (src),          \
  1039.                           (n)) = 0, __dest))          \
  1040.             : __strncat_g (__dest, (src), (n)); }))
  1041.  
  1042. __STRING_INLINE char *__strncat_g (char *__dest, __const char __src[],
  1043.                    size_t __n);
  1044.  
  1045. __STRING_INLINE char *
  1046. __strncat_g (char *__dest, __const char __src[], size_t __n)
  1047. {
  1048.   register char *__tmp = __dest;
  1049.   register char __dummy;
  1050. #ifdef __i686__
  1051.   __asm__ __volatile__
  1052.     ("repne; scasb\n"
  1053.      "movl %4, %3\n\t"
  1054.      "decl %1\n\t"
  1055.      "1:\n\t"
  1056.      "decl    %3\n\t"
  1057.      "js    2f\n\t"
  1058.      "movb    (%2),%b0\n\t"
  1059.      "movsb\n\t"
  1060.      "testb    %b0,%b0\n\t"
  1061.      "jne    1b\n\t"
  1062.      "decl    %1\n"
  1063.      "2:\n\t"
  1064.      "movb    $0,(%1)"
  1065.      : "=&a" (__dummy), "=&D" (__tmp), "=&S" (__src), "=&c" (__n)
  1066.      :  "g" (__n), "0" (0), "1" (__tmp), "2" (__src), "3" (0xffffffff)
  1067.      : "memory", "cc");
  1068. #else
  1069.   --__tmp;
  1070.   __asm__ __volatile__
  1071.     ("1:\n\t"
  1072.      "cmpb    $0,1(%1)\n\t"
  1073.      "leal    1(%1),%1\n\t"
  1074.      "jne    1b\n"
  1075.      "2:\n\t"
  1076.      "decl    %3\n\t"
  1077.      "js    3f\n\t"
  1078.      "movb    (%2),%b0\n\t"
  1079.      "leal    1(%2),%2\n\t"
  1080.      "movb    %b0,(%1)\n\t"
  1081.      "leal    1(%1),%1\n\t"
  1082.      "testb    %b0,%b0\n\t"
  1083.      "jne    2b\n\t"
  1084.      "decl    %1\n"
  1085.      "3:\n\t"
  1086.      "movb    $0,(%1)"
  1087.      : "=&q" (__dummy), "=&r" (__tmp), "=&r" (__src), "=&r" (__n)
  1088.      : "1" (__tmp), "2" (__src), "3" (__n)
  1089.      : "memory", "cc");
  1090. #endif
  1091.   return __dest;
  1092. }
  1093.  
  1094.  
  1095. /* Compare S1 and S2.  */
  1096. #define _HAVE_STRING_ARCH_strcmp 1
  1097. #define strcmp(s1, s2) \
  1098.   (__extension__ (__builtin_constant_p (s1) && __builtin_constant_p (s2)      \
  1099.           && (sizeof ((s1)[0]) != 1 || strlen (s1) >= 4)          \
  1100.           && (sizeof ((s2)[0]) != 1 || strlen (s2) >= 4)          \
  1101.           ? memcmp ((__const char *) (s1), (__const char *) (s2),     \
  1102.                 (strlen (s1) < strlen (s2)                  \
  1103.                  ? strlen (s1) : strlen (s2)) + 1)              \
  1104.           : (__builtin_constant_p (s1) && sizeof ((s1)[0]) == 1          \
  1105.              && sizeof ((s2)[0]) == 1 && strlen (s1) < 4          \
  1106.              ? (__builtin_constant_p (s2) && sizeof ((s2)[0]) == 1    \
  1107.             ? __strcmp_cc ((__const unsigned char *) (s1),          \
  1108.                        (__const unsigned char *) (s2),          \
  1109.                        strlen (s1))                  \
  1110.             : __strcmp_cg ((__const unsigned char *) (s1),          \
  1111.                        (__const unsigned char *) (s2),          \
  1112.                        strlen (s1)))                  \
  1113.              : (__builtin_constant_p (s2) && sizeof ((s1)[0]) == 1    \
  1114.             && sizeof ((s2)[0]) == 1 && strlen (s2) < 4          \
  1115.             ? (__builtin_constant_p (s1)                  \
  1116.                ? __strcmp_cc ((__const unsigned char *) (s1),     \
  1117.                       (__const unsigned char *) (s2),     \
  1118.                       strlen (s2))                  \
  1119.                : __strcmp_gc ((__const unsigned char *) (s1),     \
  1120.                       (__const unsigned char *) (s2),     \
  1121.                       strlen (s2)))                  \
  1122.             : __strcmp_gg ((s1), (s2))))))
  1123.  
  1124. #define __strcmp_cc(s1, s2, l) \
  1125.   (__extension__ ({ register int __result = (s1)[0] - (s2)[0];              \
  1126.             if (l > 0 && __result == 0)                      \
  1127.               {                                  \
  1128.             __result = (s1)[1] - (s2)[1];                  \
  1129.             if (l > 1 && __result == 0)                  \
  1130.               {                              \
  1131.                 __result = (s1)[2] - (s2)[2];              \
  1132.                 if (l > 2 && __result == 0)                  \
  1133.                   __result = (s1)[3] - (s2)[3];              \
  1134.               }                              \
  1135.               }                                  \
  1136.             __result; }))
  1137.  
  1138. #define __strcmp_cg(s1, s2, l1) \
  1139.   (__extension__ ({ __const unsigned char *__s2 = (s2);                  \
  1140.             register int __result = (s1)[0] - __s2[0];              \
  1141.             if (l1 > 0 && __result == 0)                  \
  1142.               {                                  \
  1143.             __result = (s1)[1] - __s2[1];                  \
  1144.             if (l1 > 1 && __result == 0)                  \
  1145.               {                              \
  1146.                 __result = (s1)[2] - __s2[2];              \
  1147.                 if (l1 > 2 && __result == 0)              \
  1148.                   __result = (s1)[3] - __s2[3];              \
  1149.               }                              \
  1150.               }                                  \
  1151.             __result; }))
  1152.  
  1153. #define __strcmp_gc(s1, s2, l2) \
  1154.   (__extension__ ({ __const unsigned char *__s1 = (s1);                  \
  1155.             register int __result = __s1[0] - (s2)[0];              \
  1156.             if (l2 > 0 && __result == 0)                  \
  1157.               {                                  \
  1158.             __result = __s1[1] - (s2)[1];                  \
  1159.             if (l2 > 1 && __result == 0)                  \
  1160.               {                              \
  1161.                 __result = __s1[2] - (s2)[2];              \
  1162.                 if (l2 > 2 && __result == 0)              \
  1163.                   __result = __s1[3] - (s2)[3];              \
  1164.               }                              \
  1165.               }                                  \
  1166.             __result; }))
  1167.  
  1168. __STRING_INLINE int __strcmp_gg (__const char *__s1, __const char *__s2);
  1169.  
  1170. __STRING_INLINE int
  1171. __strcmp_gg (__const char *__s1, __const char *__s2)
  1172. {
  1173.   register int __res;
  1174.   __asm__ __volatile__
  1175.     ("1:\n\t"
  1176.      "movb    (%1),%b0\n\t"
  1177.      "leal    1(%1),%1\n\t"
  1178.      "cmpb    %b0,(%2)\n\t"
  1179.      "jne    2f\n\t"
  1180.      "leal    1(%2),%2\n\t"
  1181.      "testb    %b0,%b0\n\t"
  1182.      "jne    1b\n\t"
  1183.      "xorl    %0,%0\n\t"
  1184.      "jmp    3f\n"
  1185.      "2:\n\t"
  1186.      "movl    $1,%0\n\t"
  1187.      "jb    3f\n\t"
  1188.      "negl    %0\n"
  1189.      "3:"
  1190.      : "=q" (__res), "=&r" (__s1), "=&r" (__s2)
  1191.      : "1" (__s1), "2" (__s2),
  1192.        "m" ( *(struct { char __x[0xfffffff]; } *)__s1),
  1193.        "m" ( *(struct { char __x[0xfffffff]; } *)__s2)
  1194.      : "cc");
  1195.   return __res;
  1196. }
  1197.  
  1198.  
  1199. /* Compare N characters of S1 and S2.  */
  1200. #define _HAVE_STRING_ARCH_strncmp 1
  1201. #define strncmp(s1, s2, n) \
  1202.   (__extension__ (__builtin_constant_p (s1) && strlen (s1) < ((size_t) (n))   \
  1203.           ? strcmp ((s1), (s2))                          \
  1204.           : (__builtin_constant_p (s2) && strlen (s2) < ((size_t) (n))\
  1205.              ? strcmp ((s1), (s2))                      \
  1206.              : __strncmp_g ((s1), (s2), (n)))))
  1207.  
  1208. __STRING_INLINE int __strncmp_g (__const char *__s1, __const char *__s2,
  1209.                  size_t __n);
  1210.  
  1211. __STRING_INLINE int
  1212. __strncmp_g (__const char *__s1, __const char *__s2, size_t __n)
  1213. {
  1214.   register int __res;
  1215.   __asm__ __volatile__
  1216.     ("1:\n\t"
  1217.      "decl    %3\n\t"
  1218.      "js    2f\n\t"
  1219.      "movb    (%1),%b0\n\t"
  1220.      "incl    %1\n\t"
  1221.      "cmpb    %b0,(%2)\n\t"
  1222.      "jne    3f\n\t"
  1223.      "incl    %2\n\t"
  1224.      "testb    %b0,%b0\n\t"
  1225.      "jne    1b\n"
  1226.      "2:\n\t"
  1227.      "xorl    %0,%0\n\t"
  1228.      "jmp    4f\n"
  1229.      "3:\n\t"
  1230.      "movl    $1,%0\n\t"
  1231.      "jb    4f\n\t"
  1232.      "negl    %0\n"
  1233.      "4:"
  1234.      : "=q" (__res), "=&r" (__s1), "=&r" (__s2), "=&r" (__n)
  1235.      : "1"  (__s1), "2"  (__s2),  "3" (__n),
  1236.        "m" ( *(struct { __extension__ char __x[__n]; } *)__s1),
  1237.        "m" ( *(struct { __extension__ char __x[__n]; } *)__s2)
  1238.      : "cc");
  1239.   return __res;
  1240. }
  1241.  
  1242.  
  1243. /* Find the first occurrence of C in S.  */
  1244. #define _HAVE_STRING_ARCH_strchr 1
  1245. #define _USE_STRING_ARCH_strchr 1
  1246. #define strchr(s, c) \
  1247.   (__extension__ (__builtin_constant_p (c)                      \
  1248.           ? ((c) == '\0'                          \
  1249.              ? (char *) __rawmemchr ((s), (c))                  \
  1250.              : __strchr_c ((s), ((c) & 0xff) << 8))              \
  1251.           : __strchr_g ((s), (c))))
  1252.  
  1253. __STRING_INLINE char *__strchr_c (__const char *__s, int __c);
  1254.  
  1255. __STRING_INLINE char *
  1256. __strchr_c (__const char *__s, int __c)
  1257. {
  1258.   register unsigned long int __d0;
  1259.   register char *__res;
  1260.   __asm__ __volatile__
  1261.     ("1:\n\t"
  1262.      "movb    (%0),%%al\n\t"
  1263.      "cmpb    %%ah,%%al\n\t"
  1264.      "je    2f\n\t"
  1265.      "leal    1(%0),%0\n\t"
  1266.      "testb    %%al,%%al\n\t"
  1267.      "jne    1b\n\t"
  1268.      "xorl    %0,%0\n"
  1269.      "2:"
  1270.      : "=r" (__res), "=&a" (__d0)
  1271.      : "0" (__s), "1" (__c),
  1272.        "m" ( *(struct { char __x[0xfffffff]; } *)__s)
  1273.      : "cc");
  1274.   return __res;
  1275. }
  1276.  
  1277. __STRING_INLINE char *__strchr_g (__const char *__s, int __c);
  1278.  
  1279. __STRING_INLINE char *
  1280. __strchr_g (__const char *__s, int __c)
  1281. {
  1282.   register unsigned long int __d0;
  1283.   register char *__res;
  1284.   __asm__ __volatile__
  1285.     ("movb    %%al,%%ah\n"
  1286.      "1:\n\t"
  1287.      "movb    (%0),%%al\n\t"
  1288.      "cmpb    %%ah,%%al\n\t"
  1289.      "je    2f\n\t"
  1290.      "leal    1(%0),%0\n\t"
  1291.      "testb    %%al,%%al\n\t"
  1292.      "jne    1b\n\t"
  1293.      "xorl    %0,%0\n"
  1294.      "2:"
  1295.      : "=r" (__res), "=&a" (__d0)
  1296.      : "0" (__s), "1" (__c),
  1297.        "m" ( *(struct { char __x[0xfffffff]; } *)__s)
  1298.      : "cc");
  1299.   return __res;
  1300. }
  1301.  
  1302.  
  1303. /* Find the first occurrence of C in S or the final NUL byte.  */
  1304. #define _HAVE_STRING_ARCH_strchrnul 1
  1305. #define __strchrnul(s, c) \
  1306.   (__extension__ (__builtin_constant_p (c)                      \
  1307.           ? ((c) == '\0'                          \
  1308.              ? (char *) __rawmemchr ((s), c)                  \
  1309.              : __strchrnul_c ((s), ((c) & 0xff) << 8))              \
  1310.           : __strchrnul_g ((s), c)))
  1311.  
  1312. __STRING_INLINE char *__strchrnul_c (__const char *__s, int __c);
  1313.  
  1314. __STRING_INLINE char *
  1315. __strchrnul_c (__const char *__s, int __c)
  1316. {
  1317.   register unsigned long int __d0;
  1318.   register char *__res;
  1319.   __asm__ __volatile__
  1320.     ("1:\n\t"
  1321.      "movb    (%0),%%al\n\t"
  1322.      "cmpb    %%ah,%%al\n\t"
  1323.      "je    2f\n\t"
  1324.      "leal    1(%0),%0\n\t"
  1325.      "testb    %%al,%%al\n\t"
  1326.      "jne    1b\n\t"
  1327.      "decl    %0\n"
  1328.      "2:"
  1329.      : "=r" (__res), "=&a" (__d0)
  1330.      : "0" (__s), "1" (__c),
  1331.        "m" ( *(struct { char __x[0xfffffff]; } *)__s)
  1332.      : "cc");
  1333.   return __res;
  1334. }
  1335.  
  1336. __STRING_INLINE char *__strchrnul_g (__const char *__s, int __c);
  1337.  
  1338. __STRING_INLINE char *
  1339. __strchrnul_g (__const char *__s, int __c)
  1340. {
  1341.   register unsigned long int __d0;
  1342.   register char *__res;
  1343.   __asm__ __volatile__
  1344.     ("movb    %%al,%%ah\n"
  1345.      "1:\n\t"
  1346.      "movb    (%0),%%al\n\t"
  1347.      "cmpb    %%ah,%%al\n\t"
  1348.      "je    2f\n\t"
  1349.      "leal    1(%0),%0\n\t"
  1350.      "testb    %%al,%%al\n\t"
  1351.      "jne    1b\n\t"
  1352.      "decl    %0\n"
  1353.      "2:"
  1354.      : "=r" (__res), "=&a" (__d0)
  1355.      : "0" (__s), "1" (__c),
  1356.        "m" ( *(struct { char __x[0xfffffff]; } *)__s)
  1357.      : "cc");
  1358.   return __res;
  1359. }
  1360. #ifdef __USE_GNU
  1361. # define strchrnul(s, c) __strchrnul ((s), (c))
  1362. #endif
  1363.  
  1364.  
  1365. #if defined __USE_BSD || defined __USE_XOPEN_EXTENDED
  1366. /* Find the first occurrence of C in S.  This is the BSD name.  */
  1367. # define _HAVE_STRING_ARCH_index 1
  1368. # define index(s, c) \
  1369.   (__extension__ (__builtin_constant_p (c)                      \
  1370.           ? __strchr_c ((s), ((c) & 0xff) << 8)                  \
  1371.           : __strchr_g ((s), (c))))
  1372. #endif
  1373.  
  1374.  
  1375. /* Find the last occurrence of C in S.  */
  1376. #define _HAVE_STRING_ARCH_strrchr 1
  1377. #define strrchr(s, c) \
  1378.   (__extension__ (__builtin_constant_p (c)                      \
  1379.           ? __strrchr_c ((s), ((c) & 0xff) << 8)              \
  1380.           : __strrchr_g ((s), (c))))
  1381.  
  1382. #ifdef __i686__
  1383. __STRING_INLINE char *__strrchr_c (__const char *__s, int __c);
  1384.  
  1385. __STRING_INLINE char *
  1386. __strrchr_c (__const char *__s, int __c)
  1387. {
  1388.   register unsigned long int __d0, __d1;
  1389.   register char *__res;
  1390.   __asm__ __volatile__
  1391.     ("cld\n"
  1392.      "1:\n\t"
  1393.      "lodsb\n\t"
  1394.      "cmpb    %h2,%b2\n\t"
  1395.      "cmove    %1,%0\n\t"
  1396.      "testb    %b2,%b2\n\t"
  1397.      "jne 1b"
  1398.      : "=d" (__res), "=&S" (__d0), "=&a" (__d1)
  1399.      : "0" (1), "1" (__s), "2" (__c),
  1400.        "m" ( *(struct { char __x[0xfffffff]; } *)__s)
  1401.      : "cc");
  1402.   return __res - 1;
  1403. }
  1404.  
  1405. __STRING_INLINE char *__strrchr_g (__const char *__s, int __c);
  1406.  
  1407. __STRING_INLINE char *
  1408. __strrchr_g (__const char *__s, int __c)
  1409. {
  1410.   register unsigned long int __d0, __d1;
  1411.   register char *__res;
  1412.   __asm__ __volatile__
  1413.     ("movb    %b2,%h2\n"
  1414.      "cld\n\t"
  1415.      "1:\n\t"
  1416.      "lodsb\n\t"
  1417.      "cmpb    %h2,%b2\n\t"
  1418.      "cmove    %1,%0\n\t"
  1419.      "testb    %b2,%b2\n\t"
  1420.      "jne 1b"
  1421.      : "=d" (__res), "=&S" (__d0), "=&a" (__d1)
  1422.      : "0" (1), "1" (__s), "2" (__c),
  1423.        "m" ( *(struct { char __x[0xfffffff]; } *)__s)
  1424.      : "cc");
  1425.   return __res - 1;
  1426. }
  1427. #else
  1428. __STRING_INLINE char *__strrchr_c (__const char *__s, int __c);
  1429.  
  1430. __STRING_INLINE char *
  1431. __strrchr_c (__const char *__s, int __c)
  1432. {
  1433.   register unsigned long int __d0, __d1;
  1434.   register char *__res;
  1435.   __asm__ __volatile__
  1436.     ("cld\n"
  1437.      "1:\n\t"
  1438.      "lodsb\n\t"
  1439.      "cmpb    %%ah,%%al\n\t"
  1440.      "jne    2f\n\t"
  1441.      "leal    -1(%%esi),%0\n"
  1442.      "2:\n\t"
  1443.      "testb    %%al,%%al\n\t"
  1444.      "jne 1b"
  1445.      : "=d" (__res), "=&S" (__d0), "=&a" (__d1)
  1446.      : "0" (0), "1" (__s), "2" (__c),
  1447.        "m" ( *(struct { char __x[0xfffffff]; } *)__s)
  1448.      : "cc");
  1449.   return __res;
  1450. }
  1451.  
  1452. __STRING_INLINE char *__strrchr_g (__const char *__s, int __c);
  1453.  
  1454. __STRING_INLINE char *
  1455. __strrchr_g (__const char *__s, int __c)
  1456. {
  1457.   register unsigned long int __d0, __d1;
  1458.   register char *__res;
  1459.   __asm__ __volatile__
  1460.     ("movb    %%al,%%ah\n"
  1461.      "cld\n\t"
  1462.      "1:\n\t"
  1463.      "lodsb\n\t"
  1464.      "cmpb    %%ah,%%al\n\t"
  1465.      "jne    2f\n\t"
  1466.      "leal    -1(%%esi),%0\n"
  1467.      "2:\n\t"
  1468.      "testb    %%al,%%al\n\t"
  1469.      "jne 1b"
  1470.      : "=r" (__res), "=&S" (__d0), "=&a" (__d1)
  1471.      : "0" (0), "1" (__s), "2" (__c),
  1472.        "m" ( *(struct { char __x[0xfffffff]; } *)__s)
  1473.      : "cc");
  1474.   return __res;
  1475. }
  1476. #endif
  1477.  
  1478.  
  1479. #if defined __USE_BSD || defined __USE_XOPEN_EXTENDED
  1480. /* Find the last occurrence of C in S.  This is the BSD name.  */
  1481. # define _HAVE_STRING_ARCH_rindex 1
  1482. # define rindex(s, c) \
  1483.   (__extension__ (__builtin_constant_p (c)                      \
  1484.           ? __strrchr_c ((s), ((c) & 0xff) << 8)              \
  1485.           : __strrchr_g ((s), (c))))
  1486. #endif
  1487.  
  1488.  
  1489. /* Return the length of the initial segment of S which
  1490.    consists entirely of characters not in REJECT.  */
  1491. #define _HAVE_STRING_ARCH_strcspn 1
  1492. #define strcspn(s, reject) \
  1493.   (__extension__ (__builtin_constant_p (reject) && sizeof ((reject)[0]) == 1  \
  1494.           ? ((reject)[0] == '\0'                      \
  1495.              ? strlen (s)                          \
  1496.              : ((reject)[1] == '\0'                      \
  1497.             ? __strcspn_c1 ((s), (((reject)[0] << 8) & 0xff00))   \
  1498.             : __strcspn_cg ((s), (reject), strlen (reject))))     \
  1499.           : __strcspn_g ((s), (reject))))
  1500.  
  1501. __STRING_INLINE size_t __strcspn_c1 (__const char *__s, int __reject);
  1502.  
  1503. #ifndef _FORCE_INLINES
  1504. __STRING_INLINE size_t
  1505. __strcspn_c1 (__const char *__s, int __reject)
  1506. {
  1507.   register unsigned long int __d0;
  1508.   register char *__res;
  1509.   __asm__ __volatile__
  1510.     ("1:\n\t"
  1511.      "movb    (%0),%%al\n\t"
  1512.      "leal    1(%0),%0\n\t"
  1513.      "cmpb    %%ah,%%al\n\t"
  1514.      "je    2f\n\t"
  1515.      "testb    %%al,%%al\n\t"
  1516.      "jne    1b\n"
  1517.      "2:"
  1518.      : "=r" (__res), "=&a" (__d0)
  1519.      : "0" (__s), "1" (__reject),
  1520.        "m" ( *(struct { char __x[0xfffffff]; } *)__s)
  1521.      : "cc");
  1522.   return (__res - 1) - __s;
  1523. }
  1524. #endif
  1525.  
  1526. __STRING_INLINE size_t __strcspn_cg (__const char *__s, __const char __reject[],
  1527.                     size_t __reject_len);
  1528.  
  1529. __STRING_INLINE size_t
  1530. __strcspn_cg (__const char *__s, __const char __reject[], size_t __reject_len)
  1531. {
  1532.   register unsigned long int __d0, __d1, __d2;
  1533.   register __const char *__res;
  1534.   __asm__ __volatile__
  1535.     ("cld\n"
  1536.      "1:\n\t"
  1537.      "lodsb\n\t"
  1538.      "testb    %%al,%%al\n\t"
  1539.      "je    2f\n\t"
  1540.      "movl    %5,%%edi\n\t"
  1541.      "movl    %6,%%ecx\n\t"
  1542.      "repne; scasb\n\t"
  1543.      "jne    1b\n"
  1544.      "2:"
  1545.      : "=S" (__res), "=&a" (__d0), "=&c" (__d1), "=&D" (__d2)
  1546.      : "0" (__s), "d" (__reject), "g" (__reject_len)
  1547.      : "memory", "cc");
  1548.   return (__res - 1) - __s;
  1549. }
  1550.  
  1551. __STRING_INLINE size_t __strcspn_g (__const char *__s, __const char *__reject);
  1552. #ifdef __PIC__
  1553.  
  1554. __STRING_INLINE size_t
  1555. __strcspn_g (__const char *__s, __const char *__reject)
  1556. {
  1557.   register unsigned long int __d0, __d1, __d2;
  1558.   register __const char *__res;
  1559.   __asm__ __volatile__
  1560.     ("pushl    %%ebx\n\t"
  1561.      "movl    %4,%%edi\n\t"
  1562.      "cld\n\t"
  1563.      "repne; scasb\n\t"
  1564.      "notl    %%ecx\n\t"
  1565.      "leal    -1(%%ecx),%%ebx\n"
  1566.      "1:\n\t"
  1567.      "lodsb\n\t"
  1568.      "testb    %%al,%%al\n\t"
  1569.      "je    2f\n\t"
  1570.      "movl    %4,%%edi\n\t"
  1571.      "movl    %%ebx,%%ecx\n\t"
  1572.      "repne; scasb\n\t"
  1573.      "jne    1b\n"
  1574.      "2:\n\t"
  1575.      "popl    %%ebx"
  1576.      : "=S" (__res), "=&a" (__d0), "=&c" (__d1), "=&D" (__d2)
  1577.      : "r" (__reject), "0" (__s), "1" (0), "2" (0xffffffff)
  1578.      : "memory", "cc");
  1579.   return (__res - 1) - __s;
  1580. }
  1581. #else
  1582. __STRING_INLINE size_t
  1583. __strcspn_g (__const char *__s, __const char *__reject)
  1584. {
  1585.   register unsigned long int __d0, __d1, __d2, __d3;
  1586.   register __const char *__res;
  1587.   __asm__ __volatile__
  1588.     ("cld\n\t"
  1589.      "repne; scasb\n\t"
  1590.      "notl    %%ecx\n\t"
  1591.      "leal    -1(%%ecx),%%edx\n"
  1592.      "1:\n\t"
  1593.      "lodsb\n\t"
  1594.      "testb    %%al,%%al\n\t"
  1595.      "je    2f\n\t"
  1596.      "movl    %%ebx,%%edi\n\t"
  1597.      "movl    %%edx,%%ecx\n\t"
  1598.      "repne; scasb\n\t"
  1599.      "jne    1b\n"
  1600.      "2:"
  1601.      : "=S" (__res), "=&a" (__d0), "=&c" (__d1), "=&D" (__d2), "=&d" (__d3)
  1602.      : "0" (__s), "1" (0), "2" (0xffffffff), "3" (__reject), "b" (__reject)
  1603.      /* Clobber memory, otherwise GCC cannot handle this.  */
  1604.      : "memory", "cc");
  1605.   return (__res - 1) - __s;
  1606. }
  1607. #endif
  1608.  
  1609.  
  1610. /* Return the length of the initial segment of S which
  1611.    consists entirely of characters in ACCEPT.  */
  1612. #define _HAVE_STRING_ARCH_strspn 1
  1613. #define strspn(s, accept) \
  1614.   (__extension__ (__builtin_constant_p (accept) && sizeof ((accept)[0]) == 1  \
  1615.           ? ((accept)[0] == '\0'                      \
  1616.              ? ((void) (s), 0)                          \
  1617.              : ((accept)[1] == '\0'                      \
  1618.             ? __strspn_c1 ((s), (((accept)[0] << 8 ) & 0xff00))   \
  1619.             : __strspn_cg ((s), (accept), strlen (accept))))      \
  1620.           : __strspn_g ((s), (accept))))
  1621.  
  1622. #ifndef _FORCE_INLINES
  1623. __STRING_INLINE size_t __strspn_c1 (__const char *__s, int __accept);
  1624.  
  1625. __STRING_INLINE size_t
  1626. __strspn_c1 (__const char *__s, int __accept)
  1627. {
  1628.   register unsigned long int __d0;
  1629.   register char *__res;
  1630.   /* Please note that __accept never can be '\0'.  */
  1631.   __asm__ __volatile__
  1632.     ("1:\n\t"
  1633.      "movb    (%0),%b1\n\t"
  1634.      "leal    1(%0),%0\n\t"
  1635.      "cmpb    %h1,%b1\n\t"
  1636.      "je    1b"
  1637.      : "=r" (__res), "=&q" (__d0)
  1638.      : "0" (__s), "1" (__accept),
  1639.        "m" ( *(struct { char __x[0xfffffff]; } *)__s)
  1640.      : "cc");
  1641.   return (__res - 1) - __s;
  1642. }
  1643. #endif
  1644.  
  1645. __STRING_INLINE size_t __strspn_cg (__const char *__s, __const char __accept[],
  1646.                     size_t __accept_len);
  1647.  
  1648. __STRING_INLINE size_t
  1649. __strspn_cg (__const char *__s, __const char __accept[], size_t __accept_len)
  1650. {
  1651.   register unsigned long int __d0, __d1, __d2;
  1652.   register __const char *__res;
  1653.   __asm__ __volatile__
  1654.     ("cld\n"
  1655.      "1:\n\t"
  1656.      "lodsb\n\t"
  1657.      "testb    %%al,%%al\n\t"
  1658.      "je    2f\n\t"
  1659.      "movl    %5,%%edi\n\t"
  1660.      "movl    %6,%%ecx\n\t"
  1661.      "repne; scasb\n\t"
  1662.      "je    1b\n"
  1663.      "2:"
  1664.      : "=S" (__res), "=&a" (__d0), "=&c" (__d1), "=&D" (__d2)
  1665.      : "0" (__s), "g" (__accept), "g" (__accept_len),
  1666.        /* Since we do not know how large the memory we access it, use a
  1667.       really large amount.  */
  1668.        "m" ( *(struct { char __x[0xfffffff]; } *)__s),
  1669.        "m" ( *(struct { __extension__ char __x[__accept_len]; } *)__accept)
  1670.      : "cc");
  1671.   return (__res - 1) - __s;
  1672. }
  1673.  
  1674. __STRING_INLINE size_t __strspn_g (__const char *__s, __const char *__accept);
  1675. #ifdef __PIC__
  1676.  
  1677. __STRING_INLINE size_t
  1678. __strspn_g (__const char *__s, __const char *__accept)
  1679. {
  1680.   register unsigned long int __d0, __d1, __d2;
  1681.   register __const char *__res;
  1682.   __asm__ __volatile__
  1683.     ("pushl    %%ebx\n\t"
  1684.      "cld\n\t"
  1685.      "repne; scasb\n\t"
  1686.      "notl    %%ecx\n\t"
  1687.      "leal    -1(%%ecx),%%ebx\n"
  1688.      "1:\n\t"
  1689.      "lodsb\n\t"
  1690.      "testb    %%al,%%al\n\t"
  1691.      "je    2f\n\t"
  1692.      "movl    %%edx,%%edi\n\t"
  1693.      "movl    %%ebx,%%ecx\n\t"
  1694.      "repne; scasb\n\t"
  1695.      "je    1b\n"
  1696.      "2:\n\t"
  1697.      "popl    %%ebx"
  1698.      : "=S" (__res), "=&a" (__d0), "=&c" (__d1), "=&D" (__d2)
  1699.      : "d" (__accept), "0" (__s), "1" (0), "2" (0xffffffff), "3" (__accept)
  1700.      : "memory", "cc");
  1701.   return (__res - 1) - __s;
  1702. }
  1703. #else
  1704. __STRING_INLINE size_t
  1705. __strspn_g (__const char *__s, __const char *__accept)
  1706. {
  1707.   register unsigned long int __d0, __d1, __d2, __d3;
  1708.   register __const char *__res;
  1709.   __asm__ __volatile__
  1710.     ("cld\n\t"
  1711.      "repne; scasb\n\t"
  1712.      "notl    %%ecx\n\t"
  1713.      "leal    -1(%%ecx),%%edx\n"
  1714.      "1:\n\t"
  1715.      "lodsb\n\t"
  1716.      "testb    %%al,%%al\n\t"
  1717.      "je    2f\n\t"
  1718.      "movl    %%ebx,%%edi\n\t"
  1719.      "movl    %%edx,%%ecx\n\t"
  1720.      "repne; scasb\n\t"
  1721.      "je    1b\n"
  1722.      "2:"
  1723.      : "=S" (__res), "=&a" (__d0), "=&c" (__d1), "=&D" (__d2), "=&d" (__d3)
  1724.      : "0" (__s), "1" (0), "2" (0xffffffff), "3" (__accept), "b" (__accept)
  1725.      : "memory", "cc");
  1726.   return (__res - 1) - __s;
  1727. }
  1728. #endif
  1729.  
  1730.  
  1731. /* Find the first occurrence in S of any character in ACCEPT.  */
  1732. #define _HAVE_STRING_ARCH_strpbrk 1
  1733. #define strpbrk(s, accept) \
  1734.   (__extension__ (__builtin_constant_p (accept) && sizeof ((accept)[0]) == 1  \
  1735.           ? ((accept)[0] == '\0'                      \
  1736.              ? ((void) (s), (char *) 0)                      \
  1737.              : ((accept)[1] == '\0'                      \
  1738.             ? strchr ((s), (accept)[0])                  \
  1739.             : __strpbrk_cg ((s), (accept), strlen (accept))))     \
  1740.           : __strpbrk_g ((s), (accept))))
  1741.  
  1742. __STRING_INLINE char *__strpbrk_cg (__const char *__s, __const char __accept[],
  1743.                     size_t __accept_len);
  1744.  
  1745. __STRING_INLINE char *
  1746. __strpbrk_cg (__const char *__s, __const char __accept[], size_t __accept_len)
  1747. {
  1748.   register unsigned long int __d0, __d1, __d2;
  1749.   register char *__res;
  1750.   __asm__ __volatile__
  1751.     ("cld\n"
  1752.      "1:\n\t"
  1753.      "lodsb\n\t"
  1754.      "testb    %%al,%%al\n\t"
  1755.      "je    2f\n\t"
  1756.      "movl    %5,%%edi\n\t"
  1757.      "movl    %6,%%ecx\n\t"
  1758.      "repne; scasb\n\t"
  1759.      "jne    1b\n\t"
  1760.      "decl    %0\n\t"
  1761.      "jmp    3f\n"
  1762.      "2:\n\t"
  1763.      "xorl    %0,%0\n"
  1764.      "3:"
  1765.      : "=S" (__res), "=&a" (__d0), "=&c" (__d1), "=&D" (__d2)
  1766.      : "0" (__s), "d" (__accept), "g" (__accept_len)
  1767.      : "memory", "cc");
  1768.   return __res;
  1769. }
  1770.  
  1771. __STRING_INLINE char *__strpbrk_g (__const char *__s, __const char *__accept);
  1772. #ifdef __PIC__
  1773.  
  1774. __STRING_INLINE char *
  1775. __strpbrk_g (__const char *__s, __const char *__accept)
  1776. {
  1777.   register unsigned long int __d0, __d1, __d2;
  1778.   register char *__res;
  1779.   __asm__ __volatile__
  1780.     ("pushl    %%ebx\n\t"
  1781.      "movl    %%edx,%%edi\n\t"
  1782.      "cld\n\t"
  1783.      "repne; scasb\n\t"
  1784.      "notl    %%ecx\n\t"
  1785.      "leal    -1(%%ecx),%%ebx\n"
  1786.      "1:\n\t"
  1787.      "lodsb\n\t"
  1788.      "testb    %%al,%%al\n\t"
  1789.      "je    2f\n\t"
  1790.      "movl    %%edx,%%edi\n\t"
  1791.      "movl    %%ebx,%%ecx\n\t"
  1792.      "repne; scasb\n\t"
  1793.      "jne    1b\n\t"
  1794.      "decl    %0\n\t"
  1795.      "jmp    3f\n"
  1796.      "2:\n\t"
  1797.      "xorl    %0,%0\n"
  1798.      "3:\n\t"
  1799.      "popl    %%ebx"
  1800.      : "=S" (__res), "=&a" (__d0), "=&c" (__d1), "=&D" (__d2)
  1801.      : "d" (__accept), "0" (__s), "1" (0), "2" (0xffffffff)
  1802.      : "memory", "cc");
  1803.   return __res;
  1804. }
  1805. #else
  1806. __STRING_INLINE char *
  1807. __strpbrk_g (__const char *__s, __const char *__accept)
  1808. {
  1809.   register unsigned long int __d0, __d1, __d2, __d3;
  1810.   register char *__res;
  1811.   __asm__ __volatile__
  1812.     ("movl    %%ebx,%%edi\n\t"
  1813.      "cld\n\t"
  1814.      "repne; scasb\n\t"
  1815.      "notl    %%ecx\n\t"
  1816.      "leal    -1(%%ecx),%%edx\n"
  1817.      "1:\n\t"
  1818.      "lodsb\n\t"
  1819.      "testb    %%al,%%al\n\t"
  1820.      "je    2f\n\t"
  1821.      "movl    %%ebx,%%edi\n\t"
  1822.      "movl    %%edx,%%ecx\n\t"
  1823.      "repne; scasb\n\t"
  1824.      "jne    1b\n\t"
  1825.      "decl    %0\n\t"
  1826.      "jmp    3f\n"
  1827.      "2:\n\t"
  1828.      "xorl    %0,%0\n"
  1829.      "3:"
  1830.      : "=S" (__res), "=&a" (__d0), "=&c" (__d1), "=&d" (__d2), "=&D" (__d3)
  1831.      : "0" (__s), "1" (0), "2" (0xffffffff), "b" (__accept)
  1832.      : "memory", "cc");
  1833.   return __res;
  1834. }
  1835. #endif
  1836.  
  1837.  
  1838. /* Find the first occurrence of NEEDLE in HAYSTACK.  */
  1839. #define _HAVE_STRING_ARCH_strstr 1
  1840. #define strstr(haystack, needle) \
  1841.   (__extension__ (__builtin_constant_p (needle) && sizeof ((needle)[0]) == 1  \
  1842.           ? ((needle)[0] == '\0'                      \
  1843.              ? (haystack)                          \
  1844.              : ((needle)[1] == '\0'                      \
  1845.             ? strchr ((haystack), (needle)[0])              \
  1846.             : __strstr_cg ((haystack), (needle),              \
  1847.                        strlen (needle))))              \
  1848.           : __strstr_g ((haystack), (needle))))
  1849.  
  1850. /* Please note that this function need not handle NEEDLEs with a
  1851.    length shorter than two.  */
  1852. __STRING_INLINE char *__strstr_cg (__const char *__haystack, __const char __needle[],
  1853.                    size_t __needle_len);
  1854.  
  1855. __STRING_INLINE char *
  1856. __strstr_cg (__const char *__haystack, __const char __needle[],
  1857.          size_t __needle_len)
  1858. {
  1859.   register unsigned long int __d0, __d1, __d2;
  1860.   register char *__res;
  1861.   __asm__ __volatile__
  1862.     ("cld\n" \
  1863.      "1:\n\t"
  1864.      "movl    %6,%%edi\n\t"
  1865.      "movl    %5,%%eax\n\t"
  1866.      "movl    %4,%%ecx\n\t"
  1867.      "repe; cmpsb\n\t"
  1868.      "je    2f\n\t"
  1869.      "cmpb    $0,-1(%%esi)\n\t"
  1870.      "leal    1(%%eax),%5\n\t"
  1871.      "jne    1b\n\t"
  1872.      "xorl    %%eax,%%eax\n"
  1873.      "2:"
  1874.      : "=&a" (__res), "=&S" (__d0), "=&D" (__d1), "=&c" (__d2)
  1875.      : "g" (__needle_len), "1" (__haystack), "d" (__needle)
  1876.      : "memory", "cc");
  1877.   return __res;
  1878. }
  1879.  
  1880. __STRING_INLINE char *__strstr_g (__const char *__haystack, __const char *__needle);
  1881. #ifdef __PIC__
  1882.  
  1883. __STRING_INLINE char *
  1884. __strstr_g (__const char *__haystack, __const char *__needle)
  1885. {
  1886.   register unsigned long int __d0, __d1, __d2;
  1887.   register char *__res;
  1888.   __asm__ __volatile__
  1889.     ("cld\n\t"
  1890.      "repne; scasb\n\t"
  1891.      "notl    %%ecx\n\t"
  1892.      "pushl    %%ebx\n\t"
  1893.      "decl    %%ecx\n\t"    /* NOTE! This also sets Z if searchstring='' */
  1894.      "movl    %%ecx,%%ebx\n"
  1895.      "1:\n\t"
  1896.      "movl    %%edx,%%edi\n\t"
  1897.      "movl    %%esi,%%eax\n\t"
  1898.      "movl    %%ebx,%%ecx\n\t"
  1899.      "repe; cmpsb\n\t"
  1900.      "je    2f\n\t"        /* also works for empty string, see above */
  1901.      "cmpb    $0,-1(%%esi)\n\t"
  1902.      "leal    1(%%eax),%%esi\n\t"
  1903.      "jne    1b\n\t"
  1904.      "xorl    %%eax,%%eax\n"
  1905.      "2:\n\t"
  1906.      "popl    %%ebx"
  1907.      : "=&a" (__res), "=&c" (__d0), "=&S" (__d1), "=&D" (__d2)
  1908.      : "0" (0), "1" (0xffffffff), "2" (__haystack), "3" (__needle),
  1909.        "d" (__needle)
  1910.      : "memory", "cc");
  1911.   return __res;
  1912. }
  1913. #else
  1914. __STRING_INLINE char *
  1915. __strstr_g (__const char *__haystack, __const char *__needle)
  1916. {
  1917.   register unsigned long int __d0, __d1, __d2, __d3;
  1918.   register char *__res;
  1919.   __asm__ __volatile__
  1920.     ("cld\n\t"
  1921.      "repne; scasb\n\t"
  1922.      "notl    %%ecx\n\t"
  1923.      "decl    %%ecx\n\t"    /* NOTE! This also sets Z if searchstring='' */
  1924.      "movl    %%ecx,%%edx\n"
  1925.      "1:\n\t"
  1926.      "movl    %%ebx,%%edi\n\t"
  1927.      "movl    %%esi,%%eax\n\t"
  1928.      "movl    %%edx,%%ecx\n\t"
  1929.      "repe; cmpsb\n\t"
  1930.      "je    2f\n\t"        /* also works for empty string, see above */
  1931.      "cmpb    $0,-1(%%esi)\n\t"
  1932.      "leal    1(%%eax),%%esi\n\t"
  1933.      "jne    1b\n\t"
  1934.      "xorl    %%eax,%%eax\n"
  1935.      "2:"
  1936.      : "=&a" (__res), "=&c" (__d0), "=&S" (__d1), "=&D" (__d2), "=&d" (__d3)
  1937.      : "0" (0), "1" (0xffffffff), "2" (__haystack), "3" (__needle),
  1938.        "b" (__needle)
  1939.      : "memory", "cc");
  1940.   return __res;
  1941. }
  1942. #endif
  1943.  
  1944.  
  1945. /* Bit find functions.  We define only the i686 version since for the other
  1946.    processors gcc generates good code.  */
  1947. #if defined __USE_BSD || defined __USE_XOPEN_EXTENDED
  1948. # ifdef __i686__
  1949. #  define _HAVE_STRING_ARCH_ffs 1
  1950. #  define ffs(word) (__builtin_constant_p (word)                  \
  1951.              ? __builtin_ffs (word)                      \
  1952.              : ({ int __cnt, __tmp;                      \
  1953.               __asm__ __volatile__                      \
  1954.                 ("bsfl %2,%0\n\t"                      \
  1955.                  "cmovel %1,%0"                      \
  1956.                  : "=&r" (__cnt), "=r" (__tmp)              \
  1957.                  : "rm" (word), "1" (-1));                  \
  1958.               __cnt + 1; }))
  1959.  
  1960. #  ifndef ffsl
  1961. #   define ffsl(word) ffs(word)
  1962. #  endif
  1963. # endif    /* i686 */
  1964. #endif    /* BSD || X/Open */
  1965.  
  1966. #ifndef _FORCE_INLINES
  1967. # undef __STRING_INLINE
  1968. #endif
  1969.  
  1970. #endif    /* use string inlines && GNU CC */
  1971.